{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1 align=\"center\"> Classification Trees using Python </h1>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.datasets import load_iris\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.model_selection import train_test_split\n",
    "import pandas as pd\n",
    "from sklearn import tree"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Load the Data\n",
    "The Iris dataset is one of datasets scikit-learn comes with that do not require the downloading of any file from some external website. The code below loads the iris dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sepal length (cm)</th>\n",
       "      <th>sepal width (cm)</th>\n",
       "      <th>petal length (cm)</th>\n",
       "      <th>petal width (cm)</th>\n",
       "      <th>target</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>5.1</td>\n",
       "      <td>3.5</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4.9</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>4.7</td>\n",
       "      <td>3.2</td>\n",
       "      <td>1.3</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4.6</td>\n",
       "      <td>3.1</td>\n",
       "      <td>1.5</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5.0</td>\n",
       "      <td>3.6</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   sepal length (cm)  sepal width (cm)  petal length (cm)  petal width (cm)  \\\n",
       "0                5.1               3.5                1.4               0.2   \n",
       "1                4.9               3.0                1.4               0.2   \n",
       "2                4.7               3.2                1.3               0.2   \n",
       "3                4.6               3.1                1.5               0.2   \n",
       "4                5.0               3.6                1.4               0.2   \n",
       "\n",
       "   target  \n",
       "0       0  \n",
       "1       0  \n",
       "2       0  \n",
       "3       0  \n",
       "4       0  "
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = load_iris()\n",
    "df = pd.DataFrame(data.data, columns=data.feature_names)\n",
    "df['target'] = data.target\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Splitting Data into Training and Test Sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# test_size: what proportion of original data is used for test set\n",
    "X_train, X_test, Y_train, Y_test = train_test_split(df[data.feature_names],\n",
    "                                                    df['target'],\n",
    "                                                    train_size = .75,\n",
    "                                                    random_state=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(150, 5)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(112, 4)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(38, 4)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(112,)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Y_train.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Decision Tree\n",
    "\n",
    "<b>Step 1:</b> Import the model you want to use\n",
    "\n",
    "In sklearn, all machine learning models are implemented as Python classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.tree import DecisionTreeClassifier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Step 2:</b> Make an instance of the Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "clf = DecisionTreeClassifier(max_depth = 2, \n",
    "                             random_state = 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Step 3:</b> Training the model on the data, storing the information learned from the data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Model is learning the relationship between x (features sepal width, sepal height etc) and y (labels-which species of iris)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DecisionTreeClassifier(max_depth=2, random_state=0)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clf.fit(X_train, Y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Step 4:</b> Predict the labels of new data (new flowers)\n",
    "\n",
    "Uses the information the model learned during the model training process"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uses the information the model learned during the model training process"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Returns a NumPy Array\n",
    "# Predict for One Observation (image)\n",
    "clf.predict(X_test.iloc[0].values.reshape(1, -1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Predict for Multiple Observations (images) at Once"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 1, 0, 2, 0, 2, 0, 1, 1, 1])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clf.predict(X_test[0:10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Measuring Model Performance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While there are other ways of measuring model performance (precision, recall, F1 Score, [ROC Curve](https://towardsdatascience.com/receiver-operating-characteristic-curves-demystified-in-python-bd531a4364d0), etc), we are going to keep this simple and use accuracy as our metric. \n",
    "To do this are going to see how the model performs on new data (test set)\n",
    "\n",
    "Accuracy is defined as:\n",
    "(fraction of correct predictions): correct predictions / total number of data points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8947368421052632\n"
     ]
    }
   ],
   "source": [
    "score = clf.score(X_test, Y_test)\n",
    "print(score)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Finding the Optimal `max_depth`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(1, 6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "# List of values to try for max_depth:\n",
    "max_depth_range = list(range(1, 6))\n",
    "\n",
    "# List to store the average RMSE for each value of max_depth:\n",
    "accuracy = []\n",
    "\n",
    "for depth in max_depth_range:\n",
    "    \n",
    "    clf = DecisionTreeClassifier(max_depth = depth, \n",
    "                             random_state = 0)\n",
    "    clf.fit(X_train, Y_train)\n",
    "\n",
    "    score = clf.score(X_test, Y_test)\n",
    "    accuracy.append(score)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:21: UserWarning: FixedFormatter should only be used together with FixedLocator\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(nrows = 1, ncols = 1, figsize = (10,7));\n",
    "\n",
    "ax.plot(max_depth_range,\n",
    "        accuracy,\n",
    "        lw=2,\n",
    "        color='k')\n",
    "\n",
    "ax.set_xlim([1, 5])\n",
    "ax.set_ylim([.50, 1.00])\n",
    "ax.grid(True,\n",
    "        axis = 'both',\n",
    "        zorder = 0,\n",
    "        linestyle = ':',\n",
    "        color = 'k')\n",
    "\n",
    "yticks = ax.get_yticks()\n",
    "\n",
    "y_ticklist = []\n",
    "for tick in yticks:\n",
    "    y_ticklist.append(str(tick).ljust(4, '0')[0:4])\n",
    "ax.set_yticklabels(y_ticklist)\n",
    "ax.tick_params(labelsize = 18)\n",
    "ax.set_xticks([1,2,3,4,5])\n",
    "ax.set_xlabel('max_depth', fontsize = 24)\n",
    "ax.set_ylabel('Accuracy', fontsize = 24)\n",
    "fig.tight_layout()\n",
    "fig.savefig('images/max_depth_vs_entropy.png', dpi = 300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
